SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Final (Java)</title>

</head>

final (Java)

</h1>

</header>

In the <a href="Java_(programming_language)" title="Java (programming language)">Java programming language</a>, the <code>final</code> <a href="Keyword_(computing)" class="mw-redirect" title="Keyword (computing)">keyword</a> is used in several contexts to define an entity that can only be assigned once.

Once a <code>final</code> variable has been assigned, it always contains the same value. If a <code>final</code> variable holds a reference to an object, then the state of the object may be changed by operations on the object, but the variable will always refer to the same object (this property of <code>final</code> is called non-transitivity<a href="#cite_note-1">[1]</a>). This applies also to arrays, because arrays are objects; if a <code>final</code> variable holds a reference to an array, then the components of the array may be changed by operations on the array, but the variable will always refer to the same array.<a href="#cite_note-2">[2]</a>

<div class="mw-heading mw-heading2"><h2 id="Final_classes">Final classes</h2></div>

A final <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> cannot be subclassed. As doing this can confer security and efficiency benefits, many of the Java standard library classes are final, such as <code><a rel="nofollow" class="external text" href="https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/System.html">java.lang.System</a></code> and <code><a rel="nofollow" class="external text" href="https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/String.html">java.lang.String</a></code>.

Example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public final class MyFinalClass {...}

public class ThisIsWrong extends MyFinalClass {...} // forbidden

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Final_methods">Final methods</h2></div>

A final <a href="Method_(computer_science)" class="mw-redirect" title="Method (computer science)">method</a> cannot be <a href="Method_overriding" title="Method overriding">overridden</a> or hidden by subclasses.<a href="#cite_note-3">[3]</a> This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.<a href="#cite_note-4">[4]</a>

Example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class Base

{

public void m1() {...}

public final void m2() {...}

public static final void m4() {...}

}

public class Derived extends Base

{

public void m2() {...} // forbidden

public static void m3() {...} // OK, hiding Base#m3()

public static void m4() {...} // forbidden

}

</pre></div>

A common misconception is that declaring a method as <code>final</code> improves efficiency by allowing the compiler to directly insert the method wherever it is called (see <a href="Inline_expansion" title="Inline expansion">inline expansion</a>). Because the method is loaded at <a href="Run_time_(program_lifecycle_phase)" class="mw-redirect" title="Run time (program lifecycle phase)">runtime</a>, compilers are unable to do this. Only the runtime environment and <a href="Just-in-time_compilation" title="Just-in-time compilation">JIT</a> compiler know exactly which classes have been loaded, and so only they are able to make decisions about when to inline, whether or not the method is final.<a href="#cite_note-5">[5]</a>

Machine code compilers that generate directly executable, platform-specific <a href="Machine_code" title="Machine code">machine code</a>, are an exception. When using <a href="Static_linking" class="mw-redirect" title="Static linking">static linking</a>, the compiler can safely assume that methods and variables computable at <a href="Compile-time" class="mw-redirect" title="Compile-time">compile-time</a> may be inlined.

<div class="mw-heading mw-heading2"><h2 id="Final_variables">Final variables</h2></div>

A final <a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">variable</a> can only be initialized once, either via an initializer or an assignment statement. It does not need to be initialized at the point of declaration: this is called a "blank final" variable. A blank final <a href="Instance_variable" title="Instance variable">instance variable</a> of a class must be definitely assigned in every constructor of the class in which it is declared; similarly, a blank final static variable must be definitely assigned in a static initializer of the class in which it is declared; otherwise, a compile-time error occurs in both cases.<a href="#cite_note-6">[6]</a> (Note: If the variable is a reference, this means that the variable cannot be re-bound to reference another object. But the object that it references is still <a href="Mutable_object" class="mw-redirect" title="Mutable object">mutable</a>, if it was originally mutable.)

Unlike the value of a <a href="Constant_(computer_science)" class="mw-redirect" title="Constant (computer science)">constant</a>, the value of a final variable is not necessarily known at compile time. It is considered good practice to represent final constants in all uppercase, using underscore to separate words.<a href="#cite_note-7">[7]</a>

Example:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class Sphere {

// Pi is a universal constant, about as constant as anything can be.

public static final double PI = 3.141592653589793;

public final double radius;

Sphere(double x, double y, double z, double r) {

radius = r;

xPos = x;

yPos = y;

zPos = z;

}

[...]

}

</pre></div>

Any attempt to reassign <code>radius</code>, <code>xPos</code>, <code>yPos</code>, or <code>zPos</code> will result in a compile error. In fact, even if the constructor doesn't set a final variable, attempting to set it outside the constructor will result in a compilation error.

To illustrate that finality doesn't guarantee immutability: suppose we replace the three position variables with a single one:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre> public final Position pos;

</pre></div>

where <code>pos</code> is an object with three properties <code>pos.x</code>, <code>pos.y</code> and <code>pos.z</code>. Then <code>pos</code> cannot be assigned to, but the three properties can, unless they are final themselves.

Like full <a href="Immutability" class="mw-redirect" title="Immutability">immutability</a>, the use of final variables has great advantages, especially in optimization. For instance, <code>Sphere</code> will probably have a function returning its volume; knowing that its radius is constant allows us to <a href="Memoization" title="Memoization">memoize</a> the computed volume. If we have relatively few <code>Sphere</code>s and we need their volumes very often, the performance gain might be substantial. Making the radius of a <code>Sphere</code> <code>final</code> informs developers and compilers that this sort of optimization is possible in all code that uses <code>Sphere</code>s.

Though it appears to violate the <code>final</code> principle, the following is a legal statement:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>for (final SomeObject obj : someList) {

// do something with obj

}

</pre></div>

Since the obj variable goes out of scope with each iteration of the loop, it is actually redeclared each iteration, allowing the same token (i.e. <code>obj</code>) to be used to represent multiple variables.<a href="#cite_note-8">[8]</a>

<div class="mw-heading mw-heading3"><h3 id="Final_variables_in_nested_objects">Final variables in nested objects</h3></div>

Final variables can be used to construct trees of immutable objects. Once constructed, these objects are guaranteed not to change anymore. To achieve this, an immutable class must only have final fields, and these final fields may only have immutable types themselves. Java's primitive types are immutable, as are strings and several other classes.

If the above construction is violated by having an object in the tree that is not immutable, the expectation does not hold that anything reachable via the final variable is constant. For example, the following code defines a coordinate system whose origin should always be at (0, 0). The origin is implemented using a <code>java.awt.Point</code> though, and this class defines its fields as public and modifiable. This means that even when reaching the <code>origin</code> object over an access path with only final variables, that object can still be modified, as the below example code demonstrates.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>import java.awt.Point;

public class FinalDemo {

static class CoordinateSystem {

private final Point origin = new Point(0, 0);

public Point getOrigin() { return origin; }

}

public static void main(String[] args) {

CoordinateSystem coordinateSystem = new CoordinateSystem();

coordinateSystem.getOrigin().x = 15;

assert coordinateSystem.getOrigin().getX() == 0;

}

}

</pre></div>

The reason for this is that declaring a variable final only means that this variable will point to the same object at any time. The object that the variable points to is not influenced by that final variable though. In the above example, the origin's x and y coordinates can be freely modified.

To prevent this undesirable situation, a common requirement is that all fields of an immutable object must be final, and that the types of these fields must be immutable themselves. This disqualifies <code>java.util.Date</code> and <code>java.awt.Point</code> and several other classes from being used in such immutable objects.

<div class="mw-heading mw-heading3"><h3 id="Final_and_inner_classes">Final and inner classes</h3></div>

When an anonymous <a href="Inner_class" title="Inner class">inner class</a> is defined within the body of a method, all variables declared <code>final</code> in the scope of that method are accessible from within the inner class. For scalar values, once it has been assigned, the value of the <code>final</code> variable cannot change. For object values, the reference cannot change. This allows the Java compiler to "capture" the value of the variable at run-time and store a copy as a field in the inner class. Once the outer method has terminated and its <a href="Call_stack" title="Call stack">stack frame</a> has been removed, the original variable is gone but the inner class's private copy persists in the class's own memory.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>import javax.swing.*;

public class FooGUI {

public static void main(String[] args) {

//initialize GUI components

final JFrame jf = new JFrame("Hello world!"); //allows jf to be accessed from inner class body

jf.add(new JButton("Click me"));

// pack and make visible on the Event-Dispatch Thread

SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

jf.pack(); //this would be a compile-time error if jf were not final

jf.setLocationRelativeTo(null);

jf.setVisible(true);

}

});

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Blank_final">Blank final</h3></div>

The blank final, which was introduced in Java 1.1, is a final variable whose declaration lacks an initializer.<a href="#cite_note-9">[9]</a><a href="#cite_note-10">[10]</a> Previous to Java 1.1, a final variable was required to have an initializer. A blank final, by definition of "final", can only be assigned once. i.e. it must be unassigned when an assignment occurs. In order to do this, a Java compiler runs a flow analysis to ensure that, for every assignment to a blank final variable, the variable is definitely unassigned before the assignment; otherwise a compile-time error occurs.<a href="#cite_note-define_assignment-11">[11]</a>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>final boolean hasTwoDigits;

if (number >= 10 && number < 100) {

hasTwoDigits = true;

}

if (number > -100 && number <= -10) {

hasTwoDigits = true; // compile-error because the final variable might already be assigned.

}

</pre></div>

In addition, a blank final also has to be definitely assigned before being accessed.<a href="#cite_note-define_assignment-11">[11]</a>

if (number % 2 == 0) {

isEven = true;

}

System.out.println(isEven); // compile-error because the variable was not assigned in the else-case.

</pre></div>

Note though that a non-final local variable also needs to be definitely assigned before being accessed.<a href="#cite_note-define_assignment-11">[11]</a>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>boolean isEven; // *not* final

isEven = true;

}

System.out.println(isEven); // Same compile-error because the non-final variable was not assigned in the else-case.

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="C/C++_analog_of_final_variables">C/C++ analog of final variables</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Const_(computer_programming)" title="Const (computer programming)">const (computer programming)</a></div>

In <a href="C_(programming_language)" title="C (programming language)">C</a> and <a href="C%2B%2B" title="C++">C++</a>, the analogous construct is the <code><a href="Const_(computer_programming)" title="Const (computer programming)">const</a></code> <a href="Keyword_(computer_programming)" class="mw-redirect" title="Keyword (computer programming)">keyword</a>. This differs substantially from <code>final</code> in Java, most basically in being a <a href="Type_qualifier" title="Type qualifier">type qualifier</a>: <code>const</code> is part of the <a href="Data_type" title="Data type">type</a>, not only part of the identifier (variable). This also means that the constancy of a value can be changed by casting (explicit type conversion), in this case known as "const casting". Nonetheless, casting away constness and then modifying the object results in <a href="Undefined_behavior" title="Undefined behavior">undefined behavior</a> if the object was originally declared <code>const</code>. Java's <code>final</code> is a strict rule such that it is impossible to compile code that directly breaks or bypasses the final restrictions. Using <a href="Reflection_(computer_programming)" class="mw-redirect" title="Reflection (computer programming)">reflection</a>, however, it is often possible to still modify final variables. This feature is mostly made use of when <a href="Serialization" title="Serialization">deserializing</a> objects with final members.

Further, because C and C++ expose pointers and references directly, there is a distinction between whether the pointer itself is constant, and whether the data pointed to by the pointer is constant. Applying <code>const</code> to a pointer itself, as in <code>SomeClass* const ptr</code>, means that the contents being referenced can be modified, but the reference itself cannot (without casting). This usage results in behaviour which mimics the behaviour of a <code>final</code> variable reference in Java. By contrast, when applying const to the referenced data only, as in <code>const SomeClass* ptr</code>, the contents cannot be modified (without casting), but the reference itself can. Both the reference and the contents being referenced can be declared as <code>const</code>.

In C++, the <code>final</code> keyword is used to denote that a function cannot be further overridden. It is also used similarly to Java to declare a class as final (cannot be extended).

<div class="mw-highlight mw-highlight-lang-c++ mw-content-ltr" dir="ltr"><pre>// final in a class declaration declares that a class cannot be extended

class Z final : public X, public Y {

public:

// final in a method signature declares that a method cannot be overridden further

void someOperation() override final {

// do something here

}

};

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="C#_analogs_for_final_keyword">C# analogs for final keyword</h2></div>

<a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> can be considered as similar to Java, in terms of its language features and basic syntax: Java has JVM, C# has .Net Framework; Java has bytecode, C# has MSIL; Java has no pointers (real memory) support, C# is the same.

Regarding the final keyword, C# has two related keywords:

<ol><li>The equivalent keyword for methods and classes is <code>sealed</code></li>

<li>The equivalent keyword for variables is <code>readonly</code> <a href="#cite_note-12">[12]</a></li></ol>

Note that a key difference between the C/C++ derived keyword <code>const</code> and the C# keyword <code>readonly</code> is that <code>const</code> is evaluated at compile time, while <code>readonly</code> is evaluated at runtime, and thus can have an expression that is only calculated and fixed later (at runtime).

<ul><li><a href="Final_(C%2B%2B)" class="mw-redirect" title="Final (C++)">final (C++)</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFCoblenzSunshineAldrichMyers2016" class="citation journal cs1">Coblenz, Michael; Sunshine, Joshua; Aldrich, Jonathan; Myers, Brad; Weber, Sam; Shull, Forrest (14–22 May 2016). "Exploring Language Support for Immutability". The 38th International Conference on Software Engineering.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> Java Language Specification #4.12.4

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html">"Chapter 8. Classes"</a>. docs.oracle.com. Retrieved 2024-04-25.</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/tutorial/java/IandI/final.html">"Writing Final Classes and Methods"</a>. docs.oracle.com. Retrieved 2024-04-25.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090208100217/http://www.ibm.com/developerworks/java/library/j-jtp1029.html">"Java theory and practice: Is that your final answer?"</a>. developer.ibm.com. Archived from <a rel="nofollow" class="external text" href="http://www.ibm.com/developerworks/java/library/j-jtp1029.html">the original</a> on 2009-02-08. Retrieved 2024-04-25.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> Java Language Specification #8.3.1.2.

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://petroware.no/javastyle.html">"Java Programming Style Guidelines"</a>. petroware.no. Retrieved 2024-04-25.</cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite id="CITEREFPattis" class="citation web cs1">Pattis, Richard E. <a rel="nofollow" class="external text" href="https://www.cs.cmu.edu/~pattis/15-1XX/15-200/lectures/morejava/lecture.html">"More Java"</a>. Advanced Programming/Practicum 15–200. School of Computer Science <a href="Carnegie_Mellon_University" title="Carnegie Mellon University">Carnegie Mellon University</a>. Retrieved 23 July 2010.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite id="CITEREFFlanagan1997" class="citation book cs1">Flanagan, David (May 1997). "Chapter 5 Inner Classes and Other New Language Features:5.6 Other New Features of Java 1.1". <a rel="nofollow" class="external text" href="https://archive.org/details/javainnutshelld100flan">Java in a Nutshell</a> (2nd ed.). O'Reilly. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>1-56592-262-X</bdi>.</cite>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.12.4">"Chapter 4. Types, Values, and Variables"</a>. The Java® Language Specification (Java SE 8 Edition). Oracle America, Inc. 2015. Retrieved 23 Feb 2015.</cite>

</li>

<li id="cite_note-define_assignment-11">^ <a href="#cite_ref-define_assignment_11-0">a</a> <a href="#cite_ref-define_assignment_11-1">b</a> <a href="#cite_ref-define_assignment_11-2">c</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-16.html">"Definite Assignment"</a>. The Java® Language Specification (Java SE 8 Edition). Oracle America, Inc. 2015. Retrieved 29 Oct 2016.</cite>

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <a rel="nofollow" class="external text" href="https://stackoverflow.com/questions/1327544/what-is-the-equivalent-of-javas-final-in-c">What is the equivalent of Java's final in C#?</a>

</li>

</ol></div></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-07-07" href="https://en.wikipedia.org/wiki/?title=Final_(Java)&oldid=1299311799">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>